package com.jboltai.event;

import com.jboltai.event.handler.EventHandler;

import java.util.Map;

/**
 * IEvent接口，定义了事件的基本操作和属性。
 * @param <T> 事件类型
 * @param <ResultType> 结果类型
 */
public interface IEvent<T extends Event, ResultType, H extends EventHandler> {
    /**
     * 前置检查，不满足条件的，直接报异常
     *
     * @return 返回null代表检查通过，否则返回错误信息
     */
    String preCheck();

    /**
     * 设置事件成功时的回调处理函数
     * @param successHandler 成功处理器
     * @return 当前事件
     */
    T onSuccess(SuccessHandler<T, ResultType> successHandler);

    /**
     * 触发成功回调
     * @param result
     */
    void success(ResultType result);

    /**
     * 设置事件失败时的回调处理函数
     * @param failHandler 失败处理器
     * @return 当前事件
     */
    T onFail(FailHandler<T> failHandler);

    /**
     * 触发失败回调
     * @param errorType 错误类型
     * @param errorMsg 错误消息
     * @param e 异常
     */
    void fail(EventErrorType errorType, String errorMsg, Throwable e);

    /**
     * 触发失败回调
     * @param error
     * @param errorMsg
     */
    void fail(EventErrorType error, String errorMsg);

    /**
     * 触发失败回调
     * @param error
     * @param e
     */
    void fail(EventErrorType error, Throwable e);

    /**
     * 触发失败回调
     * @param error
     */
    void fail(EventErrorType error);


    void fail(EventError error);

    /**
     * 设置事件完成时的回调处理函数
     * @param completeHandler
     * @return
     */
    T onComplete(CompleteHandler<T> completeHandler);

    /**
     * 触发取消回调
     */
    void cancel();

    /**
     * 设置事件开始时的回调处理函数
     * @param startHandler
     * @return
     */
    T onStart(StartHandler<T> startHandler);

    /**
     * 设置事件取消时的回调处理函数
     * @param cancelHandler
     * @return
     */
    T onCancel(CancelHandler<T> cancelHandler);

    /**
     * 设置事件状态改变时的回调处理函数
     * @param stateChangeHandler
     * @return
     */
    T onStateChange(StateChangeHandler<T> stateChangeHandler);

    /**
     * 触发完成回调
     */
    void complete();


    /**
     * 等待事件完成，会阻塞当前线程
     */
    void await();

    /**
     * 发布事件，会由事件调度器进行调度，不保证立即执行
     * @return
     */
    T publish();

    /**
     * 调度事件，会立即执行
     * @return
     */
    T dispatch();

    /**
     * 在事件上绑定一些数据
     * @param key
     * @param value
     * @return
     */
    T setAttr(String key, Object value);

    /**
     * 在事件上绑定一些数据
     * @param keyValues
     * @return
     */
    T setAttrs(Object... keyValues);

    /**
     * 在事件上绑定一些数据
     * @param map
     * @return
     */
    T setAttrs(Map map);

    /**
     * 根据key获取事件上绑定的数据
     * @param key
     * @return
     * @param <R>
     */
    <R> R getAttr(String key);

    /**
     * 事件是否是阻塞执行
     * @return
     */
    boolean isSync();

    /**
     * 获取事件类型
     * @return
     */
    EventType getType();

    /**
     * 获取事件id
     * @return
     */
    String getId();

    /**
     * 获取事件状态
     * @return
     */
    EventState getState();

    /**
     * 获取事件失败原因
     * @return
     */
    EventError getError();

    /**
     * 设置事件状态
     * @param state
     * @return
     */
    boolean setState(EventState state);

    /**
     * 设置事件失败原因
     * @param error
     */
    void setError(EventError error);

    /**
     * 获取事件执行结果
     * @return
     */
    ResultType getResult();

    /**
     * 设置事件执行结果
     * @param result
     */
    void setResult(ResultType result);

    /**
     * 获取事件的最长等待事件
     * @return
     */
    long getWaitTimestamp();


    /**
     * 设置事件的最长等待时间
     * @param waitTimestamp
     * @return
     */
    T setWaitTimestamp(long waitTimestamp);

    /**
     * 事件是否执行成功
     * @return
     */
    boolean isSuccess();

    /**
     * 事件是否执行失败
     * @return
     */
    boolean isFail();

    /**
     * 事件是否处理中
     * @return
     */
    boolean isProcessing();

    /**
     * 事件是否等待执行中
     * @return
     */
    boolean isWaiting();
}
